#ifndef _MUNIX_LLIST_H
#define	_MUNIX_LLIST_H
/*******************************************************************************
 ** Name: LList.h                                                             **
 ** Description: Declaration of filesystem paths.                             **
 **                                                                           **
 ** Open Source Initiative (OSI) Approved License                             **
 **                                                                           **
 **  Copyright (c) 2009-2010 Barry "Gian" James  <bjames@munixos.net>         **
 **  All rights reserved.                                                     **
 **                                                                           **
 **  Redistribution and use in source and binary forms, with or without       **
 **  modification, are permitted provided that the following conditions are   **
 **  met:                                                                     **
 **                                                                           **
 **  * Redistributions of source code must retain the above copyright notice, **
 **    this list of conditions and the following disclaimer.                  **
 **  * Redistributions in binary form must reproduce the above copyright      **
 **    notice, this list of conditions and the following disclaimer in the    **
 **    documentation and/or other materials provided with the distribution.   **
 **                                                                           **
 **  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS      **
 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED **
 ** TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           **
 ** PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT        **
 ** HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,    **
 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED  **
 ** TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR    **
 ** PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    **
 ** LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      **
 ** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        **
 ** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              **
 **                                                                           **
 ******************************************************************************/
// $Id$
// $Id$

template <class T>
class LList
{
public:
    LList() { tail = head = NULL; sz = 0; }
    ~LList();

    uint8   Add(T obj);
    uint8   Del(T obj);
    uint8   Sort();
    T       Find(T obj);
    uint8   Size() { return sz; }

private:
    struct  Node
    {
        T   data;
        Node * next;
    };
    Node * head;
    Node * tail;
    uint8   sz;
};

template<class T>
LList<T>::~LList<T>()
{
    while (head)
    {
        Node * curr = head->next;
        delete head;
        head = curr;
    }
}

template<class T>
uint8
LList<T>::Add(T obj)
{
    Node * nnode = new Node();
    nnode->data = obj;
    nnode->next = NULL;
    if (head == NULL) {
       head = nnode;
       tail = head;
    } else {
        tail->next = nnode;
        tail = tail->next;
    }
    return (++sz);
}

template<class T>
uint8
LList<T>::Del(T obj)
{
    Node * curr = head;
    Node * prev = curr;
    if (head->data == obj) {
        head = curr->next;
        delete curr;
        return (--sz);
    }
    while(curr) {
        if (obj == curr->data) {
            prev->next = curr->next;
            delete curr;
            return (--sz);
        }
        prev = curr;
        curr = curr->next;
    }
    return 0;
}

template<class T>
T
LList<T>::Find(T obj)
{
    Node * curr = head;
    while(curr) {
        if (curr->data == obj)
            return curr->data;
        curr = curr->next;
    }
    return T(NULL);
}

template<class T>
uint8
LList<T>::Sort()
{
    return 0;
}

#endif	/* _MUNIX_LLIST_H */

